home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / books / tech / ppowerpc.toc < prev    next >
Encoding:
Text File  |  1994-12-09  |  7.5 KB  |  271 lines
  1. Newsgroups: alt.books.technical
  2. Subject: "Programming the PowerPC"
  3. Date: 5 Dec 1994 17:55:29 -0500
  4.  
  5. The cover price is $40.00. The book teaches techniques for programming
  6. the new Power Macs using either the Symantec Cross-Development Kit or
  7. the Metrowerks CodeWarrior PowerPC compiler. The disk contains source
  8. code and projects for both compilers.
  9.  
  10. "Programming the PowerPC"
  11. Dan Sydow
  12. M&T Books, 1994
  13. $39.95
  14. ISBN:  1-55851-400-7
  15.  
  16. Below is the entire Table of Contents of the book so you can get an idea
  17. as to whether or not the book is of interest to you.
  18.  
  19. ___________________________________________
  20. Programming the PowerPC            
  21.  
  22. Table of Contents
  23.  
  24.  
  25. 1 The PowerPC and the Power Macs
  26.  The Need for a New Chip 
  27.   CISC and RISC
  28.   RISC Leads to More Than Just Speed
  29.  The Power Macintosh Line 
  30.   Features of the New Macs
  31.   The Customer Base
  32.  Is It Still a Mac? 
  33.   The PowerPC System Software
  34.   Software Compatibility
  35.   Hardware Compatibility
  36.   Developer Support
  37.  Chapter Summary
  38.  
  39.  
  40. 2 CISC and RISC Technologies
  41.  CISC and the 680x0 Series
  42.   Why CISC? 
  43.   Instruction Execution on a 680x0
  44.   The Timing of Intructions on a 680x0
  45.   CISC-Fast, But Not Fast Enough
  46.  RISC and the Power Mac Series
  47.   Why RISC? 
  48.   Instruction Execution on a Power Mac
  49.   The Timing of Intructions on a Power Mac
  50.  Chapter Summary
  51.  
  52.  
  53. 3 The PowerPC Architecture
  54.  Branch Processing Unit 
  55.   Instruction Fetching 
  56.   Instruction Fetching and the Branch Unit 
  57.  Superscaling 
  58.   The Superscalar Design 
  59.   Branch Processing Unit 
  60.   Integer Unit 
  61.   Floating-Point Unit 
  62.  Cache 
  63.   Data Cache
  64.   Instruction Cache 
  65.  Chapter Summary
  66.  
  67.  
  68. 4 PowerPC System Software-the Emulator and Mixed Mode 
  69.  The PowerPC System Software 
  70.   Ported System Software Routines 
  71.   The New System Software
  72.   PowerPC Execution of System Software Routines 
  73.  The 68LC040 Emulator 
  74.  The Mixed Mode Manager 
  75.   Instruction Set Architecture
  76.   Cross-Mode Calls
  77.   680x0 to PowerPC Cross-Mode Calls
  78.   PowerPC to 680x0 Cross-Mode Calls
  79.   The Programmer's Role in Mode-Switching
  80.  Chapter Summary
  81.  
  82.  
  83. 5 PowerPC System Software-Code Fragments 
  84.  The PowerPC Runtime Environment 
  85.   What the Runtime Environment Is 
  86.   A New Runtime Environment-And Why It Was Needed
  87.  Import Libraries 
  88.   Linked Libraries and Import Libraries 
  89.   Advantages of Import Libraries 
  90.  Code Fragments 
  91.   About Code Fragments 
  92.   The Code Fragment Manager 
  93.   Transition Vectors 
  94.   The Table of Contents 
  95.  Chapter Summary
  96.  
  97.  
  98. 6 PowerPC Compilers 
  99.  The Metrowerks CodeWarrior Compilers 
  100.   What Metrowerks Consists Of
  101.   Creating a CodeWarrior Project
  102.   Adding to the Project
  103.   The Prefix File
  104.   Creating the Resource File
  105.   The MWdemoPPC Source Code
  106.   Creating the PowerPC Application
  107.  Symantec's Cross-Development Kit (CDK) 
  108.   What the CDK Consists Of
  109.   Installing AppleScript
  110.   Using AppleScript to Update ANSI Libraries
  111.   Creating a Folder to Hold Your Power Mac Project
  112.   Creating the Resource File
  113.   Opening the CDK Project 
  114.   Required Resources 
  115.   The CDKdemoPPC Source Code
  116.   Creating the PowerPC Application
  117.  Chapter Summary
  118.  
  119.  
  120. 7 Universal Procedure Pointers
  121.  Universal Procedure Pointer Theory 
  122.   Procedure Pointers and the 680x0 processor
  123.   Universal Procedure Pointers and the PowerPC
  124.  Using UniversalProcPtrs
  125.   Using a UniversalProcPtr in a Call to ModalDialog()
  126.   How the Compiler Chooses Between ProcPtr and UniversalProcPtr
  127.   Using UniversalProcPtrs in Other Toolbox Calls
  128.  UniversalProcPtr Example Programs 
  129.   ModalDialog() and UPPs 
  130.   User Items and UPPs 
  131.  Chapter Summary
  132.  
  133.  
  134. 8 Fat Binary Applications
  135.  Fat Application Theory 
  136.   Structure of a 680x0 Application 
  137.   Structure of a PowerPC Application 
  138.   Structure of a Fat Application 
  139.  Using CodeWarrior to Create Fat Apps 
  140.   Creating the PowerPC Version
  141.   Creating the Fat Binary
  142.   Creating the 680x0 Version
  143.  Using Symantec's CDK to Create Fat Apps 
  144.   Creating the PowerPC Version
  145.   Creating the 680x0 Version
  146.   Creating the Fat Binary
  147.  Gracefully Exiting a PowerPC-only App 
  148.   PowerPC-only Applications and User-Friendliness
  149.    The 680x0 Resource File
  150.   The 680x0 Source Code
  151.   Copying the Resources to the PowerPC-only App
  152.  Stripping Fat Applications
  153.   Converting a Fat Binary to a PowerPC Application
  154.   Converting a Fat Binary to a 680x0 Application
  155.  Chapter Summary
  156.  
  157.  
  158. 9 The PowerPC Numerics Environment
  159.  Switching From SANE to PowerPC Numerics 
  160.  PowerPC Numerics Data Formats
  161.   The Single Format
  162.   The Double Format
  163.   The Double-Double Format
  164.   Numeric Data Format Summary
  165.  Numerics Libraries and the PowerPC
  166.  Numerics Porting Considerations
  167.   The extended and double_t Data Types
  168.   Eliminate the comp Data Type
  169.   Be Aware of How Expressions Are Evaluated
  170.  Chapter Summary
  171.  
  172.  
  173. 10 Porting Code to Native PowerPC
  174.  Porting Preparation
  175.   Use the Universal Header Files
  176.   Change Assembly Code to C Code
  177.  ANSI C and the PowerPC
  178.   Change int Variables to Other Integral Types
  179.   Use ANSI Function Declarations
  180.   Use Function Prototypes
  181.  Using a Single Source File For Both 68K and PowerPC Development 
  182.   Using Conditional Compilation Directives
  183.   QuickDraw Globals and Conditional Compilation Directives
  184.   How the Compiler Knows If a Macro Is Defined
  185.  PowerPC Compatibility 
  186.   Keep Code 32-bit Clean
  187.   Use Access Functions for Low-Memory Globals
  188.   Use Universal Procedure Pointers in Place of ProcPtrs
  189.  Data Alignment 
  190.   The 680x0 Alignment Convention
  191.   The PowerPC Alignment Convention
  192.   Potential Data Alignment Problems
  193.   The Data Alignment Solution
  194.   Testing Data Alignment
  195.   Avoiding an Alignment Switch
  196.  Chapter Summary
  197.  
  198.  
  199. 11 Import Libraries
  200.  Code Fragment Basics 
  201.   All Code is a Fragment
  202.   Fragment Code and Containers 
  203.  Import Library Basics 
  204.   Imported and Exported Symbols
  205.   Import Library Special Routines
  206.  Import Library Code 
  207.   Defining One of the Special Routines
  208.   A Second Initialization Routine Example
  209.   Import Library Advantages
  210.  Loading and Executing Import Library Code 
  211.   Creating an FSSpec For an Import Library
  212.   Loading a Library
  213.   Unloading a Library
  214.  Creating a Library With CodeWarrior 
  215.   The Import Library Resources
  216.   The Import Library Project
  217.   The Import Library Source Code
  218.  Creating a Test Application With CodeWarrior 
  219.   The Application Resources
  220.   The Application Project
  221.   The Application Source Code
  222.   Executing the Application and the Library
  223.  Loading a Library on Demand 
  224.   The Test Application's Resources
  225.   The Argument for Import Libraries
  226.   The Test Application's Code
  227.  Sharing Import Libraries 
  228.   Sharing the CompanyInfo Library Between Applications
  229.   Creating a 'shlb' Library
  230.  Chapter Summary
  231.  
  232.  
  233. 12   More Import Libraries 
  234.  Adding Icons to Applications and Libraries 
  235.   Adding an Icon to the Application
  236.   Adding an Icon to the Library
  237.  A Second Library Example 
  238.   Opening a PICT File
  239.   The Initialization Routine
  240.   The Termination Routine
  241.   The Main Routine
  242.   Using CodeWarrior to Build the Library
  243.  Modifying the TestApp2 Application 
  244.   Changes to the TestApp2 Resources
  245.   Changes to the TestApp2 Code
  246.   A Last Word on the Main Routine
  247.   Testing the PICTchooser Library
  248.  Apple Events 
  249.   Introduction to Apple Events
  250.   Responding to a Quit Application Apple Event
  251.  Adding Apple Events to an Application 
  252.   Modifying the Main Event Loop
  253.   Installing the Event Handlers
  254.   Defining the Event Handlers
  255.   Defining the Open Document Event Handler
  256.   Testing Apple Events
  257.  Chapter Summary
  258.  
  259.  
  260. 13   Optimizing PowerPC Code
  261.  Improving the Timing of WaitNextEvent() 
  262.   Using WaitNextEvent() Outside the Main Event Loop
  263.   Verifying the WaitNextEvent() Is Time Consuming
  264.   A First Solution-Fewer Calls to WaitNextEvent()
  265.   A Second Solution-Timing the Calls to WaitNextEvent()
  266.  Miscellaneous Performance Enhancements 
  267.   Align Data Structures 
  268.   Move Floating-Point Parameters to the End of the List
  269.  Chapter Summary
  270.  
  271.